openmd-cli 0.1.0__py3-none-any.whl

openmd/__init__.py

@@ -0,0 +1,3 @@
+"""Openmd package."""
+
+__version__ = "0.1.0"

openmd/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

openmd/adapters/__init__.py

@@ -0,0 +1 @@
+"""Platform adapter interfaces and registry."""

openmd/adapters/base.py

@@ -0,0 +1,95 @@
+"""Platform adapter interface and skeleton adapter implementation."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from openmd.core.detector import detect_platform, extract_first_url
+from openmd.core.models import ContentItem, TranscriptResult
+
+
+class PlatformAdapter(ABC):
+    id: str
+
+    @abstractmethod
+    def can_handle(self, input_value: str) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    def resolve_items(
+        self, input_value: str, *, limit: int | None = None, all: bool = False
+    ) -> list[ContentItem]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def extract_text(
+        self,
+        item: ContentItem,
+        *,
+        backend: str | None = None,
+        backend_chain: tuple[str, ...] | None = None,
+        allow_fallback: bool = True,
+    ) -> TranscriptResult:
+        raise NotImplementedError
+
+
+class StubPlatformAdapter(PlatformAdapter):
+    """Read-only adapter used until real platform backends are wired."""
+
+    def __init__(self, platform_id: str, default_backend: str) -> None:
+        self.id = platform_id
+        self.default_backend = default_backend
+
+    def can_handle(self, input_value: str) -> bool:
+        return detect_platform(input_value) == self.id
+
+    def resolve_items(
+        self, input_value: str, *, limit: int | None = None, all: bool = False
+    ) -> list[ContentItem]:
+        input_type = "collection" if limit is not None or all else "single"
+        source_type = "video" if self.id in {"bilibili", "youtube", "douyin", "tiktok"} else "article"
+        if self.id in {"xiaoyuzhou"}:
+            source_type = "audio"
+        if self.id in {"feishu"}:
+            source_type = "document"
+        return [
+            ContentItem(
+                platform=self.id,
+                input_type=input_type,
+                url=extract_first_url(input_value),
+                source_type=source_type,
+            )
+        ]
+
+    def extract_text(
+        self,
+        item: ContentItem,
+        *,
+        backend: str | None = None,
+        backend_chain: tuple[str, ...] | None = None,
+        allow_fallback: bool = True,
+    ) -> TranscriptResult:
+        chain = backend_chain or (backend or self.default_backend,)
+        if not allow_fallback:
+            chain = chain[:1]
+        selected_backend = chain[0] if chain else self.default_backend
+        if selected_backend == "mock":
+            return TranscriptResult(
+                text="[00:00:00] Mock transcript for Openmd skeleton.\n",
+                status="verified",
+                source_level="third_party_extractor",
+                backend="mock",
+                source_notes=["local smoke check only"],
+            )
+        return TranscriptResult(
+            text="",
+            status="failed",
+            source_level="partial_extraction",
+            backend=selected_backend,
+            source_notes=[
+                "adapter skeleton only; real extraction not implemented",
+                f"backend_chain: {' -> '.join(chain)}",
+            ],
+            error_code="backend_not_implemented",
+            error_summary="Openmd V0 skeleton routed the item but did not run a platform extractor.",
+        )

openmd/adapters/bilibili/__init__.py

@@ -0,0 +1,11 @@
+"""Bilibili V1 platform adapter."""
+
+from __future__ import annotations
+
+from openmd.adapters.base import PlatformAdapter
+
+from .adapter import BilibiliAdapter
+
+
+def create_adapter(platform_id: str, default_backend: str) -> PlatformAdapter:
+    return BilibiliAdapter(platform_id, default_backend)

openmd/adapters/bilibili/adapter.py

@@ -0,0 +1,104 @@
+"""V1 adapter for Bilibili video/audio-like package inputs."""
+
+from __future__ import annotations
+
+import hashlib
+
+from openmd.adapters.base import PlatformAdapter
+from openmd.backends.bilibili import extract_bilibili_uid, extract_bvid
+from openmd.core.detector import detect_platform, extract_first_url
+from openmd.core.models import ContentItem, TranscriptResult
+
+
+class BilibiliAdapter(PlatformAdapter):
+    """Resolve Bilibili BV and UP/collection selectors without side effects."""
+
+    def __init__(self, platform_id: str = "bilibili", default_backend: str = "bilibili-harvest.core") -> None:
+        self.id = platform_id
+        self.default_backend = default_backend
+
+    def can_handle(self, input_value: str) -> bool:
+        return detect_platform(input_value) == "bilibili"
+
+    def resolve_items(
+        self,
+        input_value: str,
+        *,
+        limit: int | None = None,
+        all: bool = False,
+    ) -> list[ContentItem]:
+        target = extract_first_url(input_value)
+        bvid = extract_bvid(target)
+        if bvid is not None:
+            return [
+                ContentItem(
+                    platform=self.id,
+                    input_type="single",
+                    url=_bilibili_video_url(bvid),
+                    id=bvid,
+                    source_type="video",
+                    raw_meta={
+                        "profile": "media",
+                        "permission_scope": "user_accessible",
+                        "content_id": bvid,
+                    },
+                )
+            ]
+
+        uid = extract_bilibili_uid(target)
+        return [
+            ContentItem(
+                platform=self.id,
+                input_type="collection",
+                url=f"https://space.bilibili.com/{uid}" if uid else target,
+                id=f"space-{uid}" if uid else _stable_id(target),
+                source_type="video",
+                raw_meta={
+                    "profile": "media",
+                    "permission_scope": "user_accessible",
+                    "collection_selector": input_value.strip(),
+                    "up_uid": uid,
+                    "discovery_limit": limit,
+                    "allow_all": all,
+                },
+            )
+        ]
+
+    def extract_text(
+        self,
+        item: ContentItem,
+        *,
+        backend: str | None = None,
+        backend_chain: tuple[str, ...] | None = None,
+        allow_fallback: bool = True,
+    ) -> TranscriptResult:
+        selected = (backend_chain or (backend or self.default_backend,))[0]
+        if selected in {"mock", "bilibili.mock"}:
+            return TranscriptResult(
+                text="[00:00:00] Mock Bilibili transcript for Openmd package smoke.\n",
+                status="verified",
+                source_level="third_party_extractor",
+                backend=selected,
+                title=item.title or item.id or "Mock Bilibili item",
+                source_notes=["local mock adapter smoke only; no network/browser/OpenCLI/media action was attempted"],
+            )
+        return TranscriptResult(
+            text="",
+            status="failed",
+            source_level="partial_extraction",
+            backend=selected,
+            source_notes=[
+                "bilibili adapter resolved the item only; real extraction is handled by gated backend providers",
+                f"allow_fallback={allow_fallback}",
+            ],
+            error_code="backend_requires_runtime_gate",
+            error_summary="Enable the appropriate Openmd backend gate before running real Bilibili extraction.",
+        )
+
+
+def _bilibili_video_url(bvid: str) -> str:
+    return f"https://www.bilibili.com/video/{bvid}/"
+
+
+def _stable_id(value: str) -> str:
+    return hashlib.sha256(value.strip().encode("utf-8")).hexdigest()[:12]

openmd/adapters/bilibili/discovery.py

@@ -0,0 +1,33 @@
+"""Bilibili discovery lane helpers.
+
+The real providers live in ``openmd.backends.bilibili`` and are registered only
+behind explicit network/browser gates. This module keeps adapter-lane imports
+stable without duplicating provider logic.
+"""
+
+from __future__ import annotations
+
+from openmd.backends.bilibili import (
+    BILIBILI_NATIVE_DISCOVERY_BACKEND,
+    BILIBILI_OPENCLI_DISCOVERY_BACKEND,
+    BilibiliNativeUserVideosProvider,
+    OpenCliBilibiliUserVideosProvider,
+    extract_bilibili_uid,
+)
+
+
+def build_opencli_bilibili_user_videos_args(selector: str, *, limit: int | None) -> list[str]:
+    uid = extract_bilibili_uid(selector) or selector.strip()
+    command = ["opencli", "bilibili", "user-videos", uid]
+    if limit is not None:
+        command.extend(["--limit", str(max(0, limit))])
+    return command
+
+
+__all__ = [
+    "BILIBILI_NATIVE_DISCOVERY_BACKEND",
+    "BILIBILI_OPENCLI_DISCOVERY_BACKEND",
+    "BilibiliNativeUserVideosProvider",
+    "OpenCliBilibiliUserVideosProvider",
+    "build_opencli_bilibili_user_videos_args",
+]

openmd/adapters/douyin/__init__.py

@@ -0,0 +1,11 @@
+"""Douyin V1 platform adapter."""
+
+from __future__ import annotations
+
+from openmd.adapters.base import PlatformAdapter
+
+from .adapter import DouyinAdapter
+
+
+def create_adapter(platform_id: str, default_backend: str) -> PlatformAdapter:
+    return DouyinAdapter(platform_id, default_backend)

openmd/adapters/douyin/adapter.py

@@ -0,0 +1,117 @@
+"""V1 adapter for Douyin author/video package inputs."""
+
+from __future__ import annotations
+
+import hashlib
+from urllib.parse import parse_qs, urlparse
+
+from openmd.adapters.base import PlatformAdapter
+from openmd.backends.douyin import douyin_user_target, normalize_douyin_collection_url
+from openmd.backends.douyin_detail import douyin_video_id
+from openmd.core.detector import detect_platform, extract_first_url
+from openmd.core.models import ContentItem, TranscriptResult
+
+
+class DouyinAdapter(PlatformAdapter):
+    """Resolve Douyin single video and author selectors without side effects."""
+
+    def __init__(self, platform_id: str = "douyin", default_backend: str = "douyin.transcript") -> None:
+        self.id = platform_id
+        self.default_backend = default_backend
+
+    def can_handle(self, input_value: str) -> bool:
+        return detect_platform(input_value) == "douyin"
+
+    def resolve_items(
+        self,
+        input_value: str,
+        *,
+        limit: int | None = None,
+        all: bool = False,
+    ) -> list[ContentItem]:
+        target = extract_first_url(input_value)
+        aweme_id = douyin_video_id(target)
+        if aweme_id is not None:
+            return [
+                ContentItem(
+                    platform=self.id,
+                    input_type="single",
+                    url=f"https://www.douyin.com/video/{aweme_id}",
+                    id=aweme_id,
+                    source_type="video",
+                    raw_meta={
+                        "profile": "media",
+                        "permission_scope": "user_accessible",
+                        "content_id": aweme_id,
+                    },
+                )
+            ]
+
+        if (urlparse(target).hostname or "").lower() == "v.douyin.com":
+            return [ContentItem(platform=self.id, input_type="single", url=target,
+                                source_type="video", raw_meta={"profile": "media", "identity_unresolved": True})]
+
+        sec_uid = douyin_user_target(target)
+        normalized = normalize_douyin_collection_url(target) or target
+        return [
+            ContentItem(
+                platform=self.id,
+                input_type="collection",
+                url=normalized,
+                id=f"user-{sec_uid}" if sec_uid else _stable_id(target),
+                source_type="video",
+                raw_meta={
+                    "profile": "media",
+                    "permission_scope": "user_accessible",
+                    "collection_selector": input_value.strip(),
+                    "sec_uid": sec_uid,
+                    "discovery_limit": limit,
+                    "allow_all": all,
+                },
+            )
+        ]
+
+    def extract_text(
+        self,
+        item: ContentItem,
+        *,
+        backend: str | None = None,
+        backend_chain: tuple[str, ...] | None = None,
+        allow_fallback: bool = True,
+    ) -> TranscriptResult:
+        selected = (backend_chain or (backend or self.default_backend,))[0]
+        if selected in {"mock", "douyin.mock"}:
+            return TranscriptResult(
+                text="[00:00:00] Mock Douyin transcript for Openmd package smoke.\n",
+                status="verified",
+                source_level="platform_transcript",
+                backend=selected,
+                title=item.title or item.id or "Mock Douyin item",
+                source_notes=["local mock adapter smoke only; no sidecar/OpenCLI/browser/account/media/ASR action was attempted"],
+            )
+        return TranscriptResult(
+            text="",
+            status="failed",
+            source_level="partial_extraction",
+            backend=selected,
+            source_notes=[
+                "douyin adapter resolved the item only; real acquisition is handled by gated discovery/backend providers",
+                f"allow_fallback={allow_fallback}",
+            ],
+            error_code="backend_requires_runtime_gate",
+            error_summary="Enable the appropriate Openmd backend gate before running real Douyin acquisition.",
+        )
+
+
+def _douyin_aweme_id(value: str) -> str | None:
+    parsed = urlparse(value if "://" in value else f"https://{value}")
+    parts = [part for part in parsed.path.split("/") if part]
+    if parts[:1] == ["video"] and len(parts) >= 2 and parts[1].isdigit():
+        return parts[1]
+    query = parse_qs(parsed.query)
+    modal = query.get("modal_id", [""])[0].strip()
+    return modal if modal.isdigit() else None
+
+
+def _stable_id(value: str) -> str:
+    return hashlib.sha256(value.strip().encode("utf-8")).hexdigest()[:12]

openmd/adapters/douyin/discovery.py

@@ -0,0 +1,36 @@
+"""Douyin discovery lane helpers.
+
+The real bounded OpenCLI discovery provider lives in ``openmd.backends.douyin``
+and is registered only behind the explicit browser backend gate.
+"""
+
+from __future__ import annotations
+
+from openmd.backends.douyin import (
+    DOUYIN_OPENMD_CREATOR_VIDEOS_BACKEND,
+    DOUYIN_OPENCLI_USER_VIDEOS_BACKEND,
+    OpenCliOpenmdDouyinCreatorVideosProvider,
+    OpenCliDouyinUserVideosProvider,
+    build_opencli_openmd_douyin_creator_videos_args,
+    build_opencli_douyin_user_videos_args,
+    classify_douyin_input_failure,
+    douyin_user_target,
+    normalize_douyin_collection_url,
+    parse_opencli_douyin_user_videos,
+    parse_opencli_openmd_douyin_creator_videos,
+)
+
+
+__all__ = [
+    "DOUYIN_OPENMD_CREATOR_VIDEOS_BACKEND",
+    "DOUYIN_OPENCLI_USER_VIDEOS_BACKEND",
+    "OpenCliOpenmdDouyinCreatorVideosProvider",
+    "OpenCliDouyinUserVideosProvider",
+    "build_opencli_openmd_douyin_creator_videos_args",
+    "build_opencli_douyin_user_videos_args",
+    "classify_douyin_input_failure",
+    "douyin_user_target",
+    "normalize_douyin_collection_url",
+    "parse_opencli_douyin_user_videos",
+    "parse_opencli_openmd_douyin_creator_videos",
+]

openmd/adapters/douyin/sidecar.py

@@ -0,0 +1,77 @@
+"""Read-only safety envelope for an optional Douyin local sidecar."""
+
+from __future__ import annotations
+
+from urllib.parse import urljoin
+
+
+ALLOWED_SIDECAR_ENDPOINTS: frozenset[tuple[str, str]] = frozenset(
+    {
+        ("GET", "/api/v1/monitors"),
+        ("GET", "/api/v1/contents"),
+        ("GET", "/api/v1/contents/:id"),
+        ("GET", "/api/v1/contents/:id/comments"),
+    }
+)
+
+FORBIDDEN_SIDECAR_PATH_PREFIXES: tuple[str, ...] = (
+    "/auth/",
+    "/api/v1/accounts",
+    "/api/v1/admin",
+    "/api/v1/creator",
+)
+
+FORBIDDEN_SIDECAR_PATH_PARTS: tuple[str, ...] = (
+    "/upload",
+    "/cancel-upload",
+    "/retry-download",
+    "/publish",
+    "/draft",
+    "/delete",
+    "/reply",
+    "/like",
+    "/approve",
+)
+
+
+def is_allowed_sidecar_endpoint(method: str, path: str) -> bool:
+    normalized_method = method.upper().strip()
+    normalized_path = _normalize_path(path)
+    if normalized_method != "GET":
+        return False
+    if any(normalized_path.startswith(prefix) for prefix in FORBIDDEN_SIDECAR_PATH_PREFIXES):
+        return False
+    if any(part in normalized_path for part in FORBIDDEN_SIDECAR_PATH_PARTS):
+        return False
+    if (normalized_method, normalized_path) in ALLOWED_SIDECAR_ENDPOINTS:
+        return True
+    return _is_content_detail_path(normalized_method, normalized_path) or _is_content_comments_path(
+        normalized_method, normalized_path
+    )
+
+
+def build_sidecar_url(base_url: str, path: str) -> str:
+    normalized_base = base_url.rstrip("/") + "/"
+    normalized_path = _normalize_path(path).lstrip("/")
+    return urljoin(normalized_base, normalized_path)
+
+
+def _is_content_detail_path(method: str, path: str) -> bool:
+    if method != "GET":
+        return False
+    parts = [part for part in path.split("/") if part]
+    return len(parts) == 4 and parts[:3] == ["api", "v1", "contents"] and parts[3].isdigit()
+
+
+def _is_content_comments_path(method: str, path: str) -> bool:
+    if method != "GET":
+        return False
+    parts = [part for part in path.split("/") if part]
+    return len(parts) == 5 and parts[:3] == ["api", "v1", "contents"] and parts[3].isdigit() and parts[4] == "comments"
+
+
+def _normalize_path(path: str) -> str:
+    value = "/" + path.strip().split("?", 1)[0].lstrip("/")
+    while "//" in value:
+        value = value.replace("//", "/")
+    return value

openmd/adapters/generic_media/__init__.py

@@ -0,0 +1,14 @@
+"""Generic media adapter factory.
+
+Local file media is currently routed through the existing ``generic_media``
+platform.  This module lets the registry discover a concrete local-audio
+adapter without editing the shared registry.
+"""
+
+from __future__ import annotations
+
+from openmd.adapters.local_audio import LocalAudioAdapter
+
+
+def create_adapter(platform_id: str, default_backend: str) -> LocalAudioAdapter:
+    return LocalAudioAdapter(platform_id, default_backend)

openmd/adapters/high_privacy.py

@@ -0,0 +1,77 @@
+"""Shared high-privacy export/cache status helpers.
+
+High-privacy social/chat lanes must report operator-actionable states without
+claiming ownership of platform sessions, browser profiles, databases, cookies,
+or decrypted local stores.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from openmd.core.models import TranscriptResult
+from openmd.core.secrets import sanitize_error_summary
+
+
+HIGH_PRIVACY_STATUS_KEY = "high_privacy_status"
+
+
+def high_privacy_status_metadata(
+    *,
+    platform: str,
+    target_kind: str,
+    state: str,
+    next_action: str,
+    permission_scope: str | None = None,
+) -> dict[str, Any]:
+    return {
+        "platform": platform,
+        "target_kind": target_kind,
+        "state": state,
+        "permission_scope": permission_scope or "unknown",
+        "next_action": sanitize_error_summary(next_action),
+        "core_owns_session": False,
+        "reads_private_database": False,
+        "decrypts_database": False,
+        "exports_cookies": False,
+        "persists_private_cache": False,
+        "requires_explicit_scope": True,
+    }
+
+
+def high_privacy_blocker_result(
+    *,
+    platform: str,
+    backend: str,
+    target_kind: str,
+    state: str,
+    error_code: str,
+    error_summary: str,
+    next_action: str,
+    permission_scope: str | None = None,
+    title: str | None = None,
+    source_notes: list[str] | None = None,
+) -> TranscriptResult:
+    return TranscriptResult(
+        text="",
+        status="failed",
+        source_level="partial_extraction",
+        backend=backend,
+        title=title,
+        source_notes=[
+            *(source_notes or []),
+            "Openmd core did not read private databases, decrypt stores, export cookies, or own platform sessions.",
+        ],
+        error_code=error_code,
+        error_summary=sanitize_error_summary(error_summary),
+        metadata={
+            "failure_class": "user_resolvable",
+            HIGH_PRIVACY_STATUS_KEY: high_privacy_status_metadata(
+                platform=platform,
+                target_kind=target_kind,
+                state=state,
+                next_action=next_action,
+                permission_scope=permission_scope,
+            ),
+        },
+    )

openmd/adapters/local_audio/__init__.py

@@ -0,0 +1,14 @@
+"""Local audio adapter lane.
+
+The detector currently routes media-like inputs to ``generic_media``.  The
+``generic_media`` adapter module reuses this local-audio adapter for local files
+without requiring platform lanes to edit the shared registry.
+"""
+
+from __future__ import annotations
+
+from .adapter import LocalAudioAdapter
+
+
+def create_adapter(platform_id: str, default_backend: str) -> LocalAudioAdapter:
+    return LocalAudioAdapter(platform_id, default_backend)